export default {
    // Common
    common: {
        confirm: 'Confirm',
        cancel: 'Cancel',
        save: 'Save',
        edit: 'Edit',
        delete: 'Delete',
        add: 'Add',
        copy: 'Copy',
        search: 'Search',
        clear: 'Clear',
        reset: 'Reset',
        close: 'Close',
        open: 'Open',
        loading: 'Loading...',
        success: 'Success',
        failed: 'Failed',
        error: 'Error',
        warning: 'Warning',
        info: 'Info',
        yes: 'Yes',
        no: 'No',
        all: 'All',
        unknown: 'Unknown',
        enable: 'Enable',
        disable: 'Disable',
        enabled: 'Enabled',
        disabled: 'Disabled',
        required: 'Required',
        optional: 'Optional',
        default: 'Default',
        custom: 'Custom',
        settings: 'Settings',
        configuration: 'Configuration',
        description: 'Description',
        name: 'Name',
        type: 'Type',
        status: 'Status',
        actions: 'Actions',
        refresh: 'Refresh',
        retry: 'Retry',
        download: 'Download',
        upload: 'Upload',
        import: 'Import',
        export: 'Export',
        characters: 'Characters',
        moreSettings: 'More Settings',
        stop: 'Stop',
        create: 'Create',
        update: 'Update'
    },

    // Page titles
    pages: {
        home: 'Home',
        chat: 'Chat',
        config: 'Configuration',
        tools: 'Tools',
        logs: 'Logs',
        statistics: 'Statistics',
        help: 'Help',
        about: 'About'
    },

    // Chat interface
    chat: {
        title: 'AI Assistant',
        quickStart: 'Quick Start:',
        emptyDescription: 'Start chatting with AI assistant!',
        inputPlaceholder: 'Enter your message...',
        sendButton: 'Send',
        stopButton: 'Stop',
        clearHistory: 'Clear History',
        retryMessage: 'Retry Message',
        copyMessage: 'Copy Message',
        processing: 'Processing...',
        generating: 'Generating...',

        // Message prompts
        messages: {
            // Basic messages
            chatServiceNotInitialized: 'Chat service not initialized',
            configError: 'Configuration error',
            clickSettingsToConfig: 'Please click settings button to configure',
            startProcessing: 'Starting to process message...',
            sendMessageFailed: 'Failed to send message',
            chatServiceError: 'Chat service error',
            mcpConfigApplied: 'MCP configuration applied',
            mcpConfigAppliedSuccess: 'MCP configuration applied successfully',
            unknownServer: 'Unknown server',

            // Message roles
            user: 'User',
            assistant: 'Assistant',

            // Reasoning process
            reasoningProcess: 'Reasoning Process',
            iterations: 'iterations',
            steps: 'steps',
            actionType: 'Action Type',
            toolName: 'Tool Name',
            parameters: 'Parameters',
            sessionId: 'Session ID',
            reasoningBasis: 'Reasoning Basis',
            success: 'Success',
            failure: 'Failure',
            duration: 'Duration {duration}ms',
            tool: 'Tool',
            result: 'Result',
            error: 'Error',
            reasoningSummary: 'Reasoning Summary',

            // Debug information
            debugInfo: 'Debug Info',
            debugInfoTitle: 'Debug Information',
            reasoningStructure: 'Reasoning Structure',
            reasoningStructureTitle: 'Reasoning Structure',
            reasoningContent: 'Reasoning Content',
            traceCheck: 'Trace Check',
            hasTrace: 'Has trace: ',
            traceIsArray: 'Trace is array: ',
            traceLength: 'Trace length: ',
            traceContent: 'Trace content: ',
            toolCallsCheck: 'Tool Calls Check',
            hasToolCalls: 'Has tool calls: ',
            toolCallsIsArray: 'Tool calls is array: ',
            toolCallsLength: 'Tool calls length: ',
            toolCallsContent: 'Tool calls content: ',
            conditionCheck: 'Condition Check',
            condition1: 'Condition 1 (has trace and length > 0): ',
            condition2: 'Condition 2 (has tool calls and length > 0): ',
            satisfied: 'Satisfied',
            notSatisfied: 'Not satisfied',
            has: 'Yes',
            notHas: 'No',
            is: 'Yes',
            notIs: 'No',
            empty: 'Empty',

            // Statistics
            traceSteps: 'Trace Steps',
            iterationCount: 'Iteration Count',
            finalStatus: 'Final Status',
            completed: 'Completed',
            notCompleted: 'Not completed',

            // Tool calls
            toolCalls: 'Tool Calls',
            tools: 'tools',
            collapse: 'Collapse',
            viewDetails: 'View Details',
            executionResult: 'Execution Result',
            errorInfo: 'Error Info',

            // Quality assessment
            qualityAssessment: 'Quality Assessment',
            score: 'pts',
            issuesFound: 'Issues Found',
            recommendations: 'Recommendations',
            cost: 'Cost: ${cost}',
            quality: 'Quality: {score}pts',

            // Action buttons
            copyMessage: 'Copy Message',
            regenerate: 'Regenerate',
            viewToolDetails: 'View Tool Details',

            // Message display related (merged from duplicate messages node)
            errorMessage: 'Error Message',
            stoppedMessage: 'User stopped message',
            normalMessage: 'Normal Message',
            reasoningStatus: 'Reasoning Status',
            reasoningDetails: 'Reasoning Details',
            detailedTrace: 'Detailed Reasoning Trace',
            mainAnswer: 'Main Answer Content',
            reasoningStats: 'Reasoning Statistics',

            // Common messages

            // Success messages
            jsonFormatCompleted: 'JSON formatting completed',
            exampleConfigLoaded: 'Example configuration loaded',
            toolListRefreshCompleted: 'Tool list refresh completed',
            settingsSavedLocally: 'Settings saved and stored locally',
            resetToDefaults: 'Reset to default settings',
            configExported: 'Configuration exported',
            configImportedApplied: 'Configuration imported and applied',

            // Error messages
            jsonFormatError: 'JSON format error, unable to format',
            loadExampleFailed: 'Failed to load example configuration',
            refreshToolsFailed: 'Failed to refresh tools',
            resetConfigFailed: 'Failed to reset configuration',
            selectModelProvider: 'Please select a model provider',
            selectOrEnterModel: 'Please select or enter a model',
            temperatureRange: 'Temperature value must be between 0-2',
            maxTokensRange: 'Max tokens must be between 1-200000',
            configureAzureEndpoint: 'Please configure Azure endpoint or base URL',
            configureDeploymentName: 'Please configure deployment name',
            configureApiVersion: 'Please configure API version',
            enterBaseUrl: 'Please enter base URL',
            exportConfigFailed: 'Failed to export configuration',
            importConfigFailed: 'Failed to import configuration',
            loadSavedConfigFailed: 'Failed to load saved configuration, using default configuration',
            readClipboardFailed: 'Failed to read from clipboard',
            autoConnectFailed: 'Error occurred during auto-connect',

            // Warning messages
            noConnectedServers: 'No connected servers',
            connectServerFirst: 'Please connect to server first',
            noAvailableTools: 'This server has no available tools',
            autoConnectCompletedAllFailed: 'Auto-connect completed, but all server connections failed'
        },

        // Chat input box

        // Chat settings
        settings: {
            title: 'Chat Settings',
            modelConfig: 'Model Configuration',
            promptConfig: 'Prompt Configuration',
            reactSettings: 'ReAct Settings',
            systemTools: 'System Tools',
            advancedSettings: 'Advanced Settings',
            saveSettings: 'Save Settings',
            cancel: 'Cancel',
            settingsSaved: 'Settings saved',
            settingsSaveFailed: 'Settings save failed'
        },

        // Tool related
        tools: {
            available: 'Available Tools',
            connected: 'Connected Tools',
            executing: 'Tool Executing',
            executed: 'Tool Executed',
            failed: 'Tool Failed',
            confirmation: 'Tool Confirmation',
            confirmationMessage: 'AI wants to call the following tools, allow?',
            confirmButton: 'Confirm Execution',
            rejectButton: 'Reject Execution',
            batchConfirmButton: 'Batch Confirm',
            timeout: 'Tool Confirmation Timeout',
            timeoutMessage: 'Tool confirmation timed out, automatically rejected'
        },

        // Message types
        messageTypes: {
            user: 'User Message',
            assistant: 'Assistant Reply',
            system: 'System Message',
            error: 'Error Message',
            tool: 'Tool Call',
            reasoning: 'Reasoning Process'
        },

        // Configuration hints
        configHint: {
            title: 'Configuration Hint',
            incomplete: 'Current model configuration is incomplete, please configure first:',
            steps: 'Click the "Chat Settings" button in the top right\nSet API key and other parameters in "Model Configuration"\nSave settings and start chatting'
        },

        // File upload
        fileUpload: {
            dragDrop: 'Drag files here or click to upload',
            dragDropActive: 'Release files to upload',
            supportedFormats: 'Supports .txt, .md, .json, .csv files',
            maxSize: 'File size cannot exceed 10MB',
            uploadSuccess: 'File uploaded successfully',
            uploadFailed: 'File upload failed',
            typeNotSupported: 'Unsupported file type',
            sizeExceeded: 'File size exceeds limit'
        },

        // Dialogs and prompts
        dialogs: {
            toolCallDetails: 'Tool Call Details',
            reactReasoningTrace: 'ReAct Reasoning Trace',
            mcpConfigTitle: 'Configure MCP Services and Tools',
            clearHistoryConfirm: 'Are you sure you want to clear conversation history? This action cannot be undone.',
            clearHistoryTitle: 'Confirm Clear',
            clearHistorySuccess: 'Conversation history cleared',
            copySuccess: 'Message copied to clipboard',
            copyFailed: 'Copy failed, please try again',
            stopProcessing: 'Stopping AI processing, completing soon...',
            stopSuccess: 'Processing stopped',

            // Common confirmation dialogs
            loadExampleConfirm: 'Loading example configuration will overwrite all current configuration content. This operation cannot be undone.',
            loadExampleTitle: 'Confirm Load Example',
            resetSettingsConfirm: 'Are you sure you want to reset to default settings? This will clear all custom configurations.',
            resetSettingsTitle: 'Reset Settings',

            // Common button text
            confirmLoad: 'Confirm Load',
            confirmReset: 'Confirm Reset'
        },

        // Configuration validation
        validation: {
            selectProvider: 'Please select model provider',
            selectModel: 'Please select or enter model',
            apiKeyRequired: 'API key required',
            azureEndpointRequired: 'Please configure Azure endpoint or base URL',
            deploymentNameRequired: 'Please configure deployment name',
            apiVersionRequired: 'Please configure API version',
            baseUrlRequired: 'Please configure base URL',
            configValid: 'Configuration validation passed'
        },

        // Quick suggestions
        quickSuggestions: {
            showAvailableTools: 'Show available tools',
            getCurrentTime: 'Get current time',
            calculateAverage: 'Calculate average for array [1,2,3,4,5]',
            viewConnectedTools: 'View {count} connected tools',
            exploreMoreTools: 'Explore more available tools',
            useTool: 'Use {toolName}',
            helpWithTask: 'Help me {message}',
            taskWithTool: 'This task can be completed using {toolName} tool from {serverName} server, which functions as: {description}',
            useToolForTask: 'Please use {toolName} tool from {serverName} server to help me complete this task.'
        },

        // Welcome messages
        welcome: {
            noTools: '👋 Hello! I am your intelligent assistant, currently no MCP tools connected. You can add tools through the "MCP Configuration" button in the top right to enhance my capabilities.',
            withTools: '👋 Hello! I am your intelligent assistant, currently connected to {toolCount} tools from {serverCount} MCP servers, can help you handle various tasks.'
        },

        // Tool confirmation
        toolConfirmation: {
            waitingConfirmation: '⏳ {message}',
            confirmed: '✅ {message}',
            rejected: '❌ {message}',
            timeout: '⏰ {message}',
            executionConfirmed: 'Tool execution confirmed, continuing processing...',
            executionRejected: 'Tool execution rejected, stopping processing',
            confirmationTimeout: 'Tool confirmation timeout, stopping processing'
        },

        // Input box related
        input: {
            placeholder: 'Enter your message, Ctrl+Enter to send...',
            enterToSend: 'Enter to send',
            ctrlEnterToSend: 'Ctrl+Enter to send',
            pleaseEnterMessage: 'Please enter message',
            filePrefix: '[File: {fileName}]',
            fileReadFailed: 'File read failed',
            uploadFile: 'Upload File',
            file: 'File',
            toolsAvailable: 'tools',
            processing: 'Processing...',
            chatSettings: 'Chat Settings',
            clearHistory: 'Clear History',
            stopProcessing: 'Stop Processing',
            sendMessage: 'Send Message',
            attachFile: 'Attach File',
            attachFileDesc: 'Supports .txt, .md, .json, .csv files',
            maxFileSize: 'File size cannot exceed 10MB',
            fileUploadSuccess: 'File uploaded successfully',
            fileUploadFailed: 'File upload failed',
            fileTypeNotSupported: 'Unsupported file type',
            fileSizeExceeded: 'File size exceeds limit',
            noFileSelected: 'Please select file to upload',
            dragDropHint: 'Drag files here or click to upload',
            dragDropActive: 'Release files to upload',
            mcpConfig: 'MCP Configuration',
            autoClear: 'Auto clear after sending',
            suggestions: 'Suggestions'
        },

        // Time related
        time: {
            justNow: 'Just now',
            minutesAgo: '{minutes} minutes ago',
            hoursAgo: '{hours} hours ago',
            processing: 'Processing...',
            stopped: 'Stopped',
            stoppedFor: 'Stopped {duration}',
            used: 'Used {duration}',
            instant: 'Instant completion',
            seconds: 'seconds',
            milliseconds: 'ms'
        },

        // Reasoning step types
        reasoningSteps: {
            thought: 'Thought',
            actionPlan: 'Action Plan',
            actionResult: 'Action Result',
            observation: 'Observation',
            reasoning: 'Reasoning',
            toolCall: 'Tool Call',
            analysis: 'Analysis',
            informationGathering: 'Information Gathering',
            error: 'Error'
        },

        // Quality assessment
        quality: {
            excellent: 'Excellent',
            good: 'Good',
            average: 'Average',
            poor: 'Poor',
            veryPoor: 'Very Poor'
        },

        // Thinking status
        thinking: {
            stopped: 'Processing stopped · {iterations} iterations total',
            reasoningWithTools: 'Intelligent reasoning · {count} tools called',
            reasoning: 'Reasoning in progress · {iteration} iteration',
            toolCalling: 'Tool calling · {count} tools',
            processing: 'Processing...',
            reasoningCompleted: 'Intelligent reasoning completed · {count} tools called',
            reasoningDone: 'Reasoning completed · {iterations} iterations',
            toolCallingCompleted: 'Tool calling completed · {count} tools',
            completed: 'Processing completed'
        },

        // Real-time reasoning display
        realtimeReasoning: {
            aiAssistant: 'AI Assistant',
            thinking: 'Thinking',
            thoughtProcess: 'Thought Process',
            steps: 'steps',
            generatingAnswer: 'Generating Answer',
            waitingForConfirmation: 'Waiting for user confirmation',
            needsConfirmation: 'Needs confirmation',
            deepThinking: 'Deep thinking',
            analyzing: 'Analyzing',
            dots: '...',
            planType: 'Plan Type:',
            tool: 'Tool:',
            parameters: 'Parameters:',
            reasoning: 'Reasoning:',
            actionExecutedSuccessfully: 'Action executed successfully',
            actionExecutionFailed: 'Action execution failed',
            finalResult: 'Final Result',
            completed: 'Completed',
            notCompleted: 'Not completed',
            answer: 'Answer',
            finalThought: 'Final Thought',
            incompleteReason: 'Incomplete reason',
            exportTrace: 'Export Trace',
            copyTrace: 'Copy Trace',
            continueReasoning: 'Continue Reasoning',
            totalSteps: 'Total Steps:',
            toolCalls: 'Tool Calls:',
            step: 'Step {step}',
            unknownStep: 'Unknown Step',
            thoughtPhase: 'Thought Phase',
            actionPlan: 'Action Plan',
            actionResult: 'Action Result',
            observationPhase: 'Observation Phase',
            maxIterationsReached: 'Maximum iterations reached',
            noMoreActions: 'No more executable actions',
            timeout: 'Execution timeout',
            error: 'Error occurred during execution',
            reasoningTraceExported: 'Reasoning trace exported',
            reactReasoningTrace: 'ReAct Reasoning Trace',
            totalIterations: 'Total Iterations:',
            totalStepsCount: 'Total Steps:',
            toolCallsCount: 'Tool Calls:',
            stepNumber: 'Step {step}: {title}',
            time: 'Time:',
            content: 'Content:',
            finalResultStatus: 'Final Result',
            status: 'Status:',
            finalAnswer: 'Answer:',
            finalThoughtLabel: 'Final Thought:'
        },

        // Tool call display
        toolCallDisplay: {
            unknownTool: 'Unknown Tool',
            success: 'Success',
            failure: 'Failed',
            toolDescription: 'Tool Description',
            callParameters: 'Call Parameters',
            executionResult: 'Execution Result',
            toolCallFailed: 'Tool call failed',
            noExecutionResult: 'No execution result',
            sessionInfo: 'Session Info',
            sessionId: 'Session ID:',
            server: 'Server:',
            executionTime: 'Execution Time:',
            copyResult: 'Copy Result',
            retryTool: 'Retry Tool',
            exportDetails: 'Export Details',
            noContentToCopy: 'No content to copy',
            toolCallDetailsExported: 'Tool call details exported',
            unknown: 'Unknown',
            milliseconds: 'ms',
            seconds: 's'
        },

        // Tool confirmation dialog
        toolConfirmationDialog: {
            toolExecutionConfirmation: 'Tool Execution Confirmation',
            aiWantsToExecute: 'AI wants to execute the following tool operations, please confirm if allowed:',
            autoRejectIn: 'seconds before auto-reject',
            executionPlan: 'Execution Plan',
            target: 'Target:',
            session: 'Session:',
            parameterList: 'Parameter List',
            securityWarning: 'Security Warning',
            editParameters: 'Edit Parameters',
            finishEditing: 'Finish Editing',
            rejectExecution: 'Reject Execution',
            confirmExecution: 'Confirm Execution',
            toolsSelected: 'tools',
            systemTool: 'System Tool',
            mcpTool: 'MCP Tool',
            toolCall: 'Tool Call',
            apiCall: 'API Call',
            tool: 'Tool',
            executeToolOperation: 'Execute tool operation',
            collapse: 'Collapse',
            details: 'Details',
            executeCommand: 'Execute system command',
            readFile: 'Read file content',
            writeFile: 'Write file content',
            listDirectory: 'List directory contents',
            searchFiles: 'Search files',
            gitOperations: 'Git operations',
            apiRequest: 'API request',
            webScraping: 'Web scraping',
            dataAnalysis: 'Data analysis',
            executeOperation: 'Execute {toolName} operation',
            null: 'null',
            array: 'array',
            string: 'string',
            number: 'number',
            boolean: 'boolean',
            object: 'object',
            securityWarningExecuteCommand: 'This operation will execute system commands, please confirm the command content is safe',
            securityWarningWriteFile: 'This operation will modify file content, please confirm carefully',
            securityWarningDeleteFile: 'This operation will delete files, the operation is irreversible, please confirm carefully',
            securityWarningApiRequest: 'This operation will send network requests, please confirm the target address is trustworthy',
            securityWarningGitOperations: 'This operation will modify Git repository, please confirm the operation is safe',
            dangerousOperationDetected: 'Potential dangerous operation detected, please verify parameter content carefully'
        }
    },

    // Configuration related
    config: {
        // ReAct configuration
        reactConfig: {
            enableReActMode: 'Enable ReAct Mode',
            enableReActModeDesc: 'Enable reasoning-action-observation loop mode for intelligent reasoning',
            maxIterations: 'Max Iterations',
            maxIterationsDesc: 'Maximum number of ReAct reasoning loops to prevent infinite loops',
            timeoutSeconds: 'Timeout (seconds)',
            timeoutDesc: 'Maximum wait time for single reasoning',
            testEngine: 'Test Reasoning Engine',
            resetDefault: 'Reset Default',
            viewAdvancedConfig: 'View Advanced Config',
            advancedConfigTitle: 'ReAct Engine Technical Details',
            currentFeatures: 'Currently Implemented Features',
            feature1: 'Reasoning-Action-Observation Loop',
            feature2: 'Multi-tool Intelligent Selection and Invocation',
            feature3: 'Cross-session Tool Discovery',
            feature4: 'Context Management and Token Control',
            feature5: 'Detailed Reasoning Trace Tracking',
            fixedConfig: 'Fixed Smart Configuration',
            configItem: 'Config Item',
            value: 'Value',
            reason: 'Reason',
            futureFeatures: 'Future Possible Features',
            futureFeature1: 'Adaptive Parameter Adjustment',
            futureFeature2: 'Reasoning Result Memory Mechanism',
            futureFeature3: 'Parallel Reasoning Branches',
            futureFeature4: 'Confidence Assessment',
            futureFeature5: 'Early Stop Condition Optimization',
            designPrinciple: 'Design Principle',
            designPrincipleDesc: 'Simple and Reliable > Complex Configuration. Current implementation focuses on core functionality stability.',
            configItem1: 'Reasoning Temperature',
            configItem2: 'Tool Call Temperature',
            configItem3: 'Max Tokens',
            configItem4: 'Tool Selection Strategy',
            configItem5: 'Iteration Count',
            reason1: 'Ensure accuracy of logical reasoning',
            reason2: 'Ensure precision of tool calls',
            reason3: 'Balance context and response speed',
            value4: 'Intelligent Matching',
            reason4: 'Select best tools based on semantic analysis',
            reason5: 'Prevent infinite loops and ensure timely response',
            testingEngine: 'Starting ReAct reasoning engine test...',
            enableReActFirst: 'Please enable ReAct mode first',
            calculatorDesc: 'Perform basic mathematical calculations',
            expressionDesc: 'Mathematical expression',
            testSuccess: 'Test successful! Time taken: {time}ms',
            testFailed: 'Test failed: {error}',
            testError: 'Test failed: {error}',
            engineNormal: 'ReAct engine basic functionality is normal',
            resetSuccess: 'Reset to default settings'
        },

        // System tools configuration
        systemTools: {
            title: 'System Tools Configuration',
            description: 'Manage built-in system tools, no external MCP connection required',
            executeAllTools: 'Execute All Tools',
            more: 'More',
            testAllTools: 'Test All Tools',
            enableAllTools: 'Enable All Tools',
            disableAllTools: 'Disable All Tools',
            resetConfig: 'Reset Config',
            exportConfig: 'Export Config',
            importConfig: 'Import Config',
            totalTools: 'Total Tools',
            enabled: 'Enabled',
            disabled: 'Disabled',
            categories: 'Categories',
            toolsList: 'Tools List',
            selectCategory: 'Select Category',
            searchTools: 'Search Tools',
            execute: 'Execute',
            test: 'Test',
            viewDetails: 'View Details',
            config: 'Config',
            connectionNormal: 'Connection Normal',
            connectionFailed: 'Connection Failed',
            toolDetails: 'Tool Details',
            basicInfo: 'Basic Information',
            toolName: 'Tool Name',
            version: 'Version',
            author: 'Author',
            category: 'Category',
            parameterDefinition: 'Parameter Definition',
            toolConfig: 'Tool Config',
            toolConfiguration: 'Tool Configuration',
            mcpReconnectConfig: 'MCP Reconnect Config',
            defaultReconnectType: 'Default Reconnect Type',
            intelligentReconnect: 'Intelligent Reconnect',
            enabledOnly: 'Enabled Only',
            allServers: 'All Servers',
            intelligentReconnectDesc: 'Intelligent reconnect: automatically select reconnect strategy based on historical status',
            disconnectFirst: 'Disconnect First',
            yes: 'Yes',
            no: 'No',
            disconnectFirstDesc: 'Whether to disconnect existing connections before reconnecting',
            showProgress: 'Show Progress Info',
            showProgressDesc: 'Whether to show detailed connection progress in console',
            connectionTimeout: 'Connection Timeout',
            milliseconds: 'ms',
            retryCount: 'Retry Count',
            retryCountDesc: 'Maximum retry count when connection fails',
            retryDelay: 'Retry Delay',
            retryDelayDesc: 'Retry interval time',
            noConfigurableItems: 'No configurable items',
            cancel: 'Cancel',
            saveConfig: 'Save Config',
            dragDropHint: 'Drag configuration file here, or',
            clickToUpload: 'click to upload',
            jsonFileOnly: 'Only JSON format configuration files can be uploaded',
            confirmImport: 'Confirm Import',
            // Additional translations for SystemToolsConfig.vue
            loadToolsFailed: 'Failed to load system tools',
            toolEnabled: 'Tool enabled',
            toolDisabled: 'Tool disabled',
            operationFailed: 'Operation failed',
            executingTool: 'Executing tool',
            toolExecutionSuccess: 'Tool execution successful',
            executionCompleted: 'Execution completed',
            toolExecutionFailed: 'Tool execution failed',
            unknownError: 'Unknown error',
            failed: 'failed',
            tool: 'Tool',
            testTool: 'Test tool',
            noEnabledTools: 'No enabled tools',
            startExecuting: 'Start executing',
            enabledToolsCount: 'enabled tools',
            executeAllToolsLog: 'Execute all tools',
            executing: 'Executing',
            executionSuccess: 'Execution successful',
            executionFailed: 'Execution failed',
            executionException: 'Execution exception',
            allToolsExecuted: 'All tools executed!',
            successCount: 'Success',
            items: 'items',
            toolExecutionCompleted: 'Tool execution completed!',
            failedCount: 'Failed',
            allToolsExecutionFailed: 'All tools execution failed!',
            testCompleted: 'Test completed',
            toolsConnectionNormal: 'tools connection normal',
            testFailed: 'Test failed',
            configSaved: 'Configuration saved successfully',
            saveConfigFailed: 'Failed to save configuration',
            allToolsEnabled: 'All tools enabled',
            allToolsDisabled: 'All tools disabled',
            resetConfigConfirm: 'This operation will reset all system tool configurations, continue?',
            resetConfigTitle: 'Confirm Reset',
            confirm: 'Confirm',
            configReset: 'Configuration reset',
            configExported: 'Configuration exported',
            exportFailed: 'Export failed',
            invalidConfigFormat: 'Invalid configuration format',
            pleaseSelectValidConfig: 'Please select a valid configuration file',
            configImported: 'Configuration imported successfully',
            importFailed: 'Import failed',
            categorySearch: 'Search',
            categoryGeneral: 'General',
            categoryUtility: 'Utility',
            categoryApi: 'API Tools',
            categoryData: 'Data Processing'
        },

        // Advanced configuration
        advanced: {
            title: 'Advanced Settings',
            description: 'Configure advanced system options',
            languageSettings: 'Language Settings',
            language: 'Interface Language',
            languageDescription: 'Select interface display language, page will refresh automatically after switching',
            functionSettings: 'Function Settings',
            autoSave: 'Auto Save',
            autoSaveDescription: 'Automatically save configuration changes to local storage',
            autoSaveInterval: 'Auto Save Interval',
            autoSaveIntervalUnit: 'seconds',
            autoSaveIntervalDescription: 'Interval time for automatically saving configuration changes',
            developerOptions: 'Developer Options',
            debugMode: 'Debug Mode',
            debugModeDescription: 'Enable detailed debug log output',
            toolExecutionSettings: 'Tool Execution Settings',
            requireToolConfirmation: 'Require Tool Confirmation',
            requireToolConfirmationActive: 'Enable',
            requireToolConfirmationInactive: 'Disable',
            requireToolConfirmationDescription: 'Require user confirmation before executing tools',
            toolConfirmationTimeout: 'Tool Confirmation Timeout',
            toolConfirmationTimeoutUnit: 'seconds',
            toolConfirmationTimeoutDescription: 'Timeout time for tool confirmation dialog',
            allowBatchToolConfirmation: 'Allow Batch Tool Confirmation',
            allowBatchToolConfirmationAllow: 'Allow',
            allowBatchToolConfirmationDisallow: 'Disallow',
            allowBatchToolConfirmationDescription: 'Allow confirming multiple tool executions at once',
            saveSettings: 'Save Settings',
            resetDefaults: 'Reset Defaults',
            clearAllData: 'Clear All Data',
            saveSuccess: 'Settings saved successfully',
            resetSuccess: 'Reset to default settings',
            clearDataSuccess: 'All data cleared',
            resetConfirm: 'Are you sure you want to reset to default settings?',
            resetConfirmTitle: 'Reset Confirmation',
            clearDataConfirm: 'Are you sure you want to clear all data? This action cannot be undone!',
            clearDataConfirmTitle: 'Clear Data Confirmation',
            clearDataConfirmButton: 'Confirm Clear'
        },

        // Model configuration
        modelConfig: {
            modelProvider: 'Model Provider',
            selectModelProvider: 'Select Model Provider',
            apiKey: 'API Key',
            inputApiKey: 'Enter API Key',
            pleaseInputApiKey: 'Please enter your {provider} API Key',
            azureEndpoint: 'Azure Endpoint',
            azureEndpointPlaceholder: 'https://your-resource.openai.azure.com',
            azureEndpointHelp: 'Azure OpenAI resource endpoint address',
            deploymentName: 'Deployment Name',
            deploymentNamePlaceholder: 'my-gpt4-deployment',
            deploymentNameHelp: 'Deployment name created in Azure',
            apiVersion: 'API Version',
            apiVersionPlaceholder: '2025-01-01-preview',
            apiVersionHelp: 'Azure OpenAI API version, recommended to use 2025-01-01-preview',
            model: 'Model',
            modelPlaceholder: 'Enter model name',
            modelHelp: 'Please enter model name',
            baseUrl: 'Base URL',
            baseUrlPlaceholder: 'Enter API endpoint URL',
            baseUrlHelp: 'Custom API endpoint',
            temperature: 'Temperature',
            temperatureHelp: 'Controls output randomness, 0=deterministic, 2=most random',
            maxTokens: 'Max Tokens',
            maxTokensHelp: 'Maximum tokens for single response',
            maxContextTokens: 'Context Tokens',
            maxContextTokensHelp: 'Maximum tokens for conversation history context, used for ReAct reasoning context management',
            topP: 'Top P',
            topPHelp: 'Nucleus sampling parameter, controls vocabulary selection diversity',
            advancedOptions: 'Advanced Options',
            frequencyPenalty: 'Frequency Penalty',
            frequencyPenaltyHelp: 'Reduce repetitive content generation',
            presencePenalty: 'Presence Penalty',
            presencePenaltyHelp: 'Encourage generating new topic content',
            seed: 'Seed Value',
            seedPlaceholder: 'Leave empty for random',
            seedHelp: 'Fixed seed value for reproducible results',
            streamOutput: 'Stream Output',
            enable: 'Enable',
            disable: 'Disable',
            streamOutputHelp: 'Real-time display of generated content when enabled',
            testConnection: 'Test Connection',
            resetToDefaults: 'Reset to Defaults',
            connectionTestSuccess: 'Connection test successful! Response time: {time}ms',
            connectionTestFailed: 'Connection test failed: {error}',
            connectionTestError: 'Connection test failed: {error}',
            pleaseSelectProvider: 'Please select model provider',
            pleaseConfigureModel: 'Please configure model first',
            pleaseInputApiKeyForProvider: '{provider} requires API key',
            azureNeedsApiKey: 'Azure requires API key',
            pleaseSelectOrInputModel: 'Please select or enter model',
            pleaseConfigureAzureEndpoint: 'Please configure Azure endpoint or complete API URL',
            pleaseConfigureDeploymentName: 'Deployment name required when using Azure endpoint',
            configValidationFailed: 'Configuration validation failed, please check required fields',
            pleaseConfigureAzureEndpointAndDeployment: 'Please configure Azure endpoint and deployment name, or complete API URL',
            notSupportTestProvider: 'Testing {provider} provider is not supported yet',
            hasResetToDefaults: 'Reset to default settings',
            temperatureConservative: 'Conservative',
            temperatureBalanced: 'Balanced',
            temperatureCreative: 'Creative',
            temperatureVeryCreative: 'Very Creative',
            penaltyEncourage: 'Encourage',
            penaltyNeutral: 'Neutral',
            penaltyPunish: 'Punish',
            unknownSize: 'Unknown size',
            unknownTime: 'Unknown time',
            // Model provider names
            openai: 'OpenAI',
            anthropic: 'Anthropic',
            deepseek: 'DeepSeek',
            dashscope: 'Tongyi Qianwen',
            custom: 'Custom',
            azure: 'Azure OpenAI',
            // Model placeholders
            openaiModelPlaceholder: 'e.g.: gpt-4.1-mini, gpt-3.5-turbo, gpt-4-turbo',
            anthropicModelPlaceholder: 'e.g.: claude-3-opus, claude-3-sonnet, claude-3-haiku',
            deepseekModelPlaceholder: 'e.g.: deepseek-chat, deepseek-coder',
            dashscopeModelPlaceholder: 'e.g.: qwen-turbo, qwen-plus, qwen-max',
            customModelPlaceholder: 'Enter custom model name',
            azureModelPlaceholder: 'e.g.: gpt-4.1-mini, gpt-35-turbo (for request identification)',
            // Model help text
            openaiModelHelp: 'Please enter OpenAI model name, supports all latest released models',
            anthropicModelHelp: 'Please enter Anthropic Claude model name',
            deepseekModelHelp: 'Please enter DeepSeek model name, supports chat and code models',
            dashscopeModelHelp: 'Please enter Tongyi Qianwen model name',
            customModelHelp: 'Please enter custom model name compatible with OpenAI API',
            azureModelHelp: 'Enter actual model name (like gpt-4.1-mini, gpt-35-turbo), not deployment name',
            // Base URL placeholders and help
            customBaseUrlPlaceholder: 'e.g.: https://api.custom-ai.com/v1',
            customBaseUrlHelp: 'Enter custom endpoint address compatible with OpenAI API',
            // Validation rules
            pleaseSelectModelProvider: 'Please select model provider',
            temperatureRange: 'Temperature value should be between 0-2',
            tokenRange: 'Token count should be between 1-32000',
            contextTokenRange: 'Context token count should be between 1000-1000000',
            pleaseInputAzureEndpoint: 'Please enter Azure endpoint',
            pleaseInputDeploymentName: 'Please enter deployment name',
            pleaseInputApiVersion: 'Please enter API version',
            pleaseInputBaseUrl: 'Please enter base URL'
        },

        // Prompt configuration
        promptConfig: {
            reactSystemPrompt: 'ReAct System Prompt',
            reactSystemPromptPlaceholder: 'Enter ReAct system prompt...',
            reactSystemPromptHelp: 'ReAct system prompt defines AI assistant\'s reasoning-action-observation pattern, including tool calling, error handling and complete workflow',
            presetTemplates: 'Preset Templates',
            selectPresetTemplate: 'Select Preset Template',
            selectPresetTemplateHelp: 'Select preset template to quickly configure prompts',
            availableVariables: 'Available Variables and ReAct Format Instructions',
            availableVariablesTitle: 'Available Variables',
            mcpToolsVariable: '- Dynamic tool list, format: - Tool name: Description',
            requiredReactFormatTags: 'Required ReAct Format Tags',
            reasoningTag: 'Reasoning process, AI analyzes user requests and formulates plans',
            actionTag: 'Tool calling, contains JSON format tool name and parameters',
            finalAnswerTag: 'Final answer, AI\'s reply to user',
            actionFormatExample: 'ACTION Format Example',
            validatePrompts: 'Validate Prompts',
            resetToDefaults: 'Reset to Defaults',
            exportConfig: 'Export Config',
            importConfig: 'Import Config',
            importPromptConfig: 'Import Prompt Configuration',
            pasteJsonConfig: 'Paste JSON configuration...',
            cancel: 'Cancel',
            import: 'Import',
            promptValidationFailed: 'Validation failed:\n{issues}',
            reactSystemPromptCannotBeEmpty: 'ReAct system prompt cannot be empty',
            missingReasoningTag: 'ReAct prompt missing <REASONING> tag',
            missingActionTag: 'ReAct prompt missing <ACTION> tag',
            missingFinalAnswerTag: 'ReAct prompt missing <FINAL_ANSWER> tag',
            missingMcpToolsVariable: 'ReAct prompt missing {mcpTools} variable',
            reactSystemPromptValidationPassed: 'ReAct system prompt validation passed!',
            confirmReset: 'Are you sure you want to reset to default prompts?',
            resetConfirmation: 'Reset Confirmation',
            confirm: 'Confirm',
            hasResetToDefaults: 'Reset to default settings',
            promptConfigExported: 'Prompt configuration exported',
            promptConfigImported: 'Prompt configuration imported successfully',
            invalidConfigFormat: 'Invalid configuration format',
            importFailed: 'Import failed: {error}',
            // Templates
            defaultReactAssistant: 'Default ReAct Assistant',
            defaultReactAssistantDesc: 'Standard ReAct reasoning mode',
            developerReactAssistant: 'Developer ReAct Assistant',
            developerReactAssistantDesc: 'ReAct mode focused on code development',
            testerReactAssistant: 'Tester ReAct Assistant',
            testerReactAssistantDesc: 'ReAct mode focused on software testing',
            templateLoaded: 'Loaded {name} template',
            // Additional translations for PromptConfig.vue
            toolNameExample: 'tool-name',
            parameterValueExample: 'parameter-value',
            // Additional translations for ReActConfig.vue
            reactTestResults: 'ReAct test results:'
        }
    },

    // MCP Configuration
    mcp: {
        title: 'MCP Configuration Center',
        serverManagement: 'Server Management',
        configEditor: 'Configuration Editor',

        // Configuration center page
        configCenter: {
            title: 'Test MCP Configuration Center',
            subtitle: 'Test Model Context Protocol Platform',
            refreshConfig: 'Refresh Configuration',
            apiAddress: 'API Address (LiteMCP):',
            editApiAddress: 'Edit API Address',
            resetToDefault: 'Reset to Default Address',

            // Editor related
            jsonEditor: 'JSON Configuration Editor',
            validateConfig: 'Validate Configuration',
            formatJson: 'Format',
            loadExample: 'Load Example',
            jsonPlaceholder: 'Paste or edit MCP server configuration JSON...',
            validationSuccess: 'Configuration validation passed! Detected {count} servers',
            configFormatError: 'Configuration format error: missing mcpServers',
            jsonSyntaxError: 'JSON syntax error: {error}',

            // Pagination and search
            searchPlaceholder: 'Search server names, descriptions or tools...',
            filterResults: 'Filter Results',
            itemsPerPage: 'Items per page',
            items3: '3 items',
            items5: '5 items',
            items10: '10 items',
            items20: '20 items',
            paginationInfo: 'Showing {start} - {end} of {total} servers',
            filteredFrom: 'Filtered from {total} servers',

            // Server related
            newConfig: 'New Config',
            noDescription: 'No description',
            tools: 'tools',
            collapseTools: 'Collapse Tools',
            expandTools: 'Expand Tools',
            deleteServer: 'Delete Server',
            cannotDeleteEnabledServer: 'Cannot delete enabled server. Please disable it first.',
            deleteServerTitle: 'Confirm Delete Server',
            deleteServerConfirm: 'Are you sure you want to delete server "{name}"? This action cannot be undone.',
            serverDeleted: 'Server "{name}" has been deleted',
            deleteServerFailed: 'Failed to delete server: {error}',
            configParseError: 'Configuration parsing failed',
            serverNotFound: 'Server "{name}" not found in configuration',
            availableToolsList: 'Available Tools List ({count} items)',
            enableAll: 'Enable All',
            disableAll: 'Disable All',
            viewDetails: 'View Details',

            // Empty state
            noSearchResults: 'No server configurations found containing \'{keyword}\'',
            addServerConfig: 'Please add server configuration in JSON editor',
            loadExampleConfig: 'Load Example Configuration',
            clearSearch: 'Clear Search',

            // Loading state
            loadingConfigCenter: 'Loading configuration center...',
            loadingDescription: 'Fetching MCP server configuration list',

            // Server operation messages
            serverDisconnected: 'Disconnected {name}',
            serverDisconnectFailed: 'Failed to disconnect server {name}: {error}',

            // Pagination options
            items6: '6 items/page',
            items8: '8 items/page',
            items12: '12 items/page',
            items18: '18 items/page',

            // Search results
            foundResults: 'Found {count} matching results',
            pageInfo: 'Items {start} - {end}',

            // Statistics cards
            stats: {
                totalServers: 'Total Servers',
                stdioServers: 'STDIO Servers',
                sseServers: 'SSE Servers',
                streamableServers: 'Streamable HTTP',
                totalTools: 'Total Tools',
                suggestion: 'Recommended ≤40',
                externalMcp: 'External MCP Services',
                running: 'Running',
                clickToManage: 'Click to Manage',
                externalMcpTooltip: 'Manage third-party MCP service configurations like GitHub, GitLab, time services, etc.'
            },

            // Server types
            serverTypes: {
                sse: 'SSE Servers',
                sseDesc: 'MCP server configuration using Server-Sent Events communication',
                streamable: 'Streamable HTTP Servers',
                streamableDesc: 'MCP server configuration using streaming HTTP protocol communication',
                stdio: 'STDIO Servers',
                stdioDesc: 'MCP server configuration using standard input/output communication'
            },

            // Proxy information
            proxy: {
                title: 'Proxy Server Information',
                host: 'Host Address:',
                port: 'Port:',
                baseUrl: 'Base URL:',
                generatedAt: 'Generated At:'
            },

            // Empty state
            emptyState: 'No MCP server configuration',

             // Messages
             messages: {
                 apiUrlUpdated: 'API address updated',
                 apiUrlInvalid: 'Please enter valid API address',
                 apiUrlReset: 'Reset to default API address',
                 fetchConfigFailed: 'Failed to fetch MCP server configuration',
                 fetchStatsFailed: 'Failed to fetch statistics',
                 updateConfigFailed: 'Failed to update MCP configuration',
                 chatError: 'Chat error'
             }
        },

        // Server card
        serverCard: {
            addToAssistant: 'Add to Assistant',
            copyConfig: 'Copy Configuration',
            editConfig: 'Edit Configuration',
            command: 'Command',
            args: 'Arguments',
            url: 'URL',
            configCopied: 'Configuration copied to clipboard',
            copyFailed: 'Copy failed'
        },

        // Connection status
        connection: {
            connected: 'Connected',
            disconnected: 'Disconnected',
            connecting: 'Connecting',
            failed: 'Connection Failed',
            reconnecting: 'Reconnecting'
        },

        // Tool status
        tools: {
            available: 'Available',
            unavailable: 'Unavailable',
            loading: 'Loading',
            error: 'Error'
        },

        // Tools panel
        toolsPanel: {
            availableTools: 'Available Tools ({count})',
            refreshTools: 'Refresh Tools',
            execute: 'Execute',
            noDescription: 'No description',
            parameters: 'Parameters',
            required: 'Required',
            noTools: 'No available tools',
            executeTool: 'Execute Tool: {name}',
            description: 'Description',
            noParams: 'This tool requires no parameters',
            executeToolButton: 'Execute Tool',
            executionResult: 'Tool Execution Result',
            inputParameters: 'Input Parameters',
            copyResult: 'Copy Result',
            fieldRequired: '{field} is required',
            fieldMinLength: '{field} needs at least {min} characters',
            fieldMaxLength: '{field} needs at most {max} characters',
            addItem: 'Add {name}',
            executionSuccess: 'Tool execution successful',
            executionFailed: 'Tool execution failed: {error}'
        },

        // Dialogs
        dialogs: {
            statistics: {
                title: 'Tool Statistics Details',
                projectStats: 'Project Statistics',
                authorStats: 'Author Statistics',
                totalProjects: 'Total Projects',
                totalAuthors: 'Total Authors',
                totalTools: 'Total Tools',
                toolsTooltip: 'The sum of tools in the table may be greater than this number because one tool may involve multiple projects',
                projectName: 'Project Name',
                serverCount: 'Server Count',
                toolCount: 'Tool Count',
                authorCount: 'Author Count',
                authorList: 'Author List',
                authorName: 'Author Name',
                toolPercentage: 'Tool Percentage'
            },
            toolDetail: {
                title: 'Tool Details',
                loading: 'Loading tool details...',
                basicInfo: 'Basic Information',
                toolName: 'Tool Name',
                modulePath: 'Module Path',
                returnType: 'Return Type',
                createTime: 'Create Time',
                author: 'Author',
                authorTooltip: 'Department: {department} Email: {email}',
                noEmail: 'None',
                unknownAuthor: 'Unknown Author',
                relatedProjects: 'Related Projects',
                parameterInfo: 'Parameter Information',
                parameterList: 'Parameter List',
                inputSchema: 'Input Schema',
                loadFailed: 'Tool details loading failed',
                noDescription: 'No description',
                notFound: 'Tool details not found',
                fetchFailed: 'Failed to fetch tool details: {error}',
                networkError: 'Network error'
            },
            toolsDetail: {
                projectToolsTitle: 'Tools List for Project "{name}"',
                authorToolsTitle: 'Tools List for Author "{name}"',
                totalTools: 'Total Tools',
                project: 'Project',
                author: 'Author',
                toolName: 'Tool Name',
                description: 'Description',
                serverName: 'Server Name',
                authorName: 'Author Name',
                department: 'Department',
                parameters: 'Parameters',
                returnType: 'Return Type',
                noParameters: 'No Parameters',
                noTools: 'No Tools',
                fetchError: 'Failed to fetch tools list'
            }
        },

        // External MCP Management
        externalManager: {
            title: 'External MCP Service Management',
            manage: 'Manage External MCP',

            // Instance management
            createInstance: 'Create Instance',
            editInstance: 'Edit Instance',
            deleteInstance: 'Delete Instance',
            instanceName: 'Instance Name',
            templateName: 'Template Name',
            description: 'Description',
            command: 'Command',
            environment: 'Environment Variables',
            enabled: 'Enabled',
            disabled: 'Disabled',
            status: 'Status',

            // Search and filter
            searchPlaceholder: 'Search instance name, command or description...',
            allStatus: 'All Status',

            // Batch operations
            batchOperations: 'Batch Operations',
            selectedCount: 'Selected {count} instances',
            batchEnable: 'Batch Enable',
            batchDisable: 'Batch Disable',
            batchDelete: 'Batch Delete',

            // Statistics
            totalInstances: 'Total Instances',
            enabledInstances: 'Enabled Instances',
            disabledInstances: 'Disabled Instances',
            refreshPending: 'Changes pending, config will refresh when dialog closes',

            // Environment variables
            envVars: 'Environment Variables',

            // Operation confirmations
            deleteConfirm: 'Are you sure to delete instance "{name}"? This action cannot be undone.',
            cannotDeleteEnabled: 'Cannot delete enabled instance "{name}". Please disable it first.',
            cannotDeleteEnabledBatch: 'Cannot delete {count} enabled instances: {names}. Please disable them first.',
            cannotDeleteEnabledTooltip: 'Enabled instances cannot be deleted. Please disable first.',
            batchDeleteConfirm: 'Are you sure to delete {count} selected instances? This action cannot be undone.',

            // Operation messages
            loadDataError: 'Failed to load data',
            refreshSuccess: 'Data refreshed successfully',
            deleteSuccess: 'Instance deleted successfully',
            deleteError: 'Failed to delete instance',
            enableSuccess: 'Instance "{name}" enabled successfully',
            enableError: 'Failed to enable instance',
            disableSuccess: 'Instance "{name}" disabled successfully',
            disableError: 'Failed to disable instance',
            createSuccess: 'Instance created successfully',
            createError: 'Failed to create instance',
            updateSuccess: 'Instance updated successfully',
            updateError: 'Failed to update instance',

            // Batch operation messages
            noDisabledSelected: 'No disabled instances selected',
            noEnabledSelected: 'No enabled instances selected',
            noInstancesSelected: 'No instances selected',
            batchEnableSuccess: 'Batch enable completed successfully, {count} instances',
            batchEnableError: 'Batch enable failed',
            batchDisableSuccess: 'Batch disable completed successfully, {count} instances',
            batchDisableError: 'Batch disable failed',
            batchDeleteSuccess: 'Batch delete completed successfully, {count} instances',
            batchDeleteError: 'Batch delete failed'
        },

        // Instance Form
        instanceForm: {
            createTitle: 'Create MCP Instance',
            editTitle: 'Edit MCP Instance',
            basicInfo: 'Basic Information',
            environment: 'Environment Variables',
            preview: 'Preview',

            // Basic information
            templateName: 'Template Name',
            selectTemplate: 'Select Template',
            instanceName: 'Instance Name',
            instanceNamePlaceholder: 'Please enter instance name',
            description: 'Description',
            descriptionPlaceholder: 'Please enter instance description (optional)',
            enabled: 'Enable Status',
            enabledText: 'Enabled',
            disabledText: 'Disabled',
            status: 'Status',

            // New configuration parsing related
            mcpConfigTitle: 'MCP Server Configuration',
            supportedCommands: 'Supports npx, uvx, node, python commands',
            pasteConfig: 'Paste Configuration',
            configPlaceholder: 'Please paste your MCP configuration JSON, for example:\n\nFull format: Contains mcpServers object\nSimplified format: Direct command, args, env fields\n\nSupports npx, uvx, node, python commands\nSupports environment variable configuration',
            parseConfig: 'Parse Configuration',
            clearConfig: 'Clear Configuration',
            fillExample: 'Fill Example',
            exampleFilled: 'Example configuration filled, please click parse configuration',
            pasteConfigHint: 'Please paste your MCP server configuration, the system will automatically parse and generate the form',
            parsedConfigTitle: 'Parsing Results',
            configParsed: 'Configuration Parsed',
            detectedCommand: 'Detected Command',
            detectedArgs: 'Detected Arguments',
            detectedEnvVars: 'Detected Environment Variables',
            noEnvVars: 'No environment variables',
            personalizedConfig: 'Personalized Configuration',
            configureEnvVars: 'Configure Environment Variables',
            requiredField: 'Required field',
            advancedConfig: 'Advanced Configuration',

            // Parsing error messages
            invalidConfigFormat: 'Invalid configuration format',
            noServersFound: 'No server configuration found',
            missingCommand: 'Missing start command',
            unsupportedCommand: 'Unsupported command: {command}, recommend using npx or uvx',
            configParsedSuccess: 'Configuration parsed successfully',
            configParseError: 'Configuration parsing failed',
            pleaseParseConfig: 'Please parse the configuration before submitting',
            createError: 'Failed to create instance',
            updateError: 'Failed to update instance',
            jsonFormatRequired: 'JSON format',
            noArgs: 'No arguments',
            requiredEnvCount: 'Need to configure {count} required environment variables',
            configParseSuccess: 'Configuration parsed successfully, please fill in personalized information',

            // Command configuration
            commandConfig: 'Command Configuration',
            command: 'Start Command',
            commandPlaceholder: 'Please enter start command',
            arguments: 'Command Arguments',
            argumentPlaceholder: 'Argument {index}',
            addArgument: 'Add Argument',
            timeout: 'Timeout',
            timeoutHint: 'Unit: seconds, range: 1-300',
            autoRestart: 'Auto Restart',
            autoRestartEnabled: 'Enabled',
            autoRestartDisabled: 'Disabled',

            // Environment variables
            environmentVariables: 'Environment Variables',
            addEnvVar: 'Add Environment Variable',
            envKeyPlaceholder: 'Variable Name',
            envValuePlaceholder: 'Variable Value',
            noEnvironmentVariables: 'No environment variables',

            // Preview
            configurationPreview: 'Configuration Preview',
            commandPreview: 'Command Preview',
            environmentPreview: 'Environment Variables Preview',
            variable: 'Variable',
            value: 'Value',
            seconds: 'seconds',

            // Form validation
            templateRequired: 'Please select a template',
            instanceNameRequired: 'Please enter instance name',
            instanceNameLength: 'Instance name length must be between 2-50 characters',
            instanceNameFormat: 'Instance name can only contain letters, numbers, underscores and hyphens',
            commandRequired: 'Please enter start command',
            timeoutRequired: 'Please enter timeout',
            timeoutRange: 'Timeout must be between 1-300 seconds'
        }
    }
}